;;; -*- Mode: Lisp; Package: CCL; Coding: utf-8; -*-

(chapter "About {CCL}"
    "{CCL} is a fast, mature, open source Common Lisp
      implementation that runs on Linux, Mac OS X, FreeBSD, and Windows.
      {CCL} was forked from Macintosh Common Lisp (MCL) in 1998
      and the development has been entirely separate since.
    

      When it was forked from MCL in 1998, the new Lisp was named
      OpenMCL. Subsequently, Clozure renamed its Lisp to {CCL}, partly
      because its ancestor MCL has been released as open
      source. Clozure thought it might be confusing for users if there
      were two independent open-source projects with such similar
      names. The new name also reflects {CCL}'s current status as the
      flagship product of Clozure Associates.

      Furthermore, the new name refers to {CCL}'s ancestry: in its
      early years, MCL was known as Coral Common Lisp, or “CCL”. For
      years the package that contains most of {CCL}'s
      implementation-specific symbols has been named “CCL”, an acronym
      that once stood for the name of the Lisp product. It seems
      fitting that “CCL” once again stands for the name of the
      product.

      Some commands and source files may still refer to “OpenMCL”
      instead of {CCL}.

      {CCL} compiles to native code and supports multithreading
      using native OS threads. It includes a foreign-function interface,
      and supports both Lisp code that calls external code, and external
      code that calls Lisp code. {CCL} can create standalone executables
      on all supported platforms.

      On Mac OS X, {CCL} supports building GUI applications that
      use OS X's native Cocoa frameworks, and the OS X distributions
      include an IDE written with Cocoa, and distributed with complete
      sources.

      On all supported platforms, {CCL} can run as a command-line
      process, or as an inferior Emacs process using either SLIME or
      ILISP.

Features of {CCL} include"
    (listing :bullet
      (item "Very fast compilation speed.")
      (item "A fast, precise, compacting, generational
      garbage collector written in hand-optimized C. The sizes of the
      generations are fully configurable. Typically, a generation can
      be collected in a millisecond on modern
      systems.")
      (item "Fast execution speed, competitive with other
      Common Lisp implementations on most
      benchmarks.")
      (item "Robust and stable. Customers report that their
      CPU-intensive, multi-threaded applications run for extended
      periods on {CCL} without difficulty.")
      (item "Full native OS threads on all platforms. Threads
      are automatically distributed across multiple cores. The API
      includes support for shared memory, locking, and blocking for OS
      operations such as I/O.")
      (item "Full Unicode support.")
      (item "Full SLIME integration.")
      (item "An IDE on Mac OS X, fully integrated with
      the Macintosh window system and User Interface
      standards.")
      (item "Excellent debugging facilities. The names of all
      local variables are available in a backtrace.")
      (item "A complete, mature foreign function interface,
      including a powerful bridge to Objective-C and Cocoa on Mac OS
      X.")
      (item "Many extensions including: files mapped to
      Common Lisp vectors for fast file I/O; thread-local hash tables
      and streams to eliminate locking overhead; cons hashing support;
      and much more")
      (item "Very efficient use of memory"))
    (para "Although it's an open-source project, available free of
      charge under a liberal license, {CCL} is also a fully-supported
      product of Clozure Associates. Clozure continues to extend,
      improve, and develop {CCL} in response to customer and user
      needs, and offers full support and development services for
      {CCL}."))
